package org.example.compnent.Parser;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.example.common.enums.FileParser;
import org.example.common.result.FileParseResult;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import static cn.hutool.poi.excel.cell.CellUtil.getCellValue;


/**Xlsx文件（Excel 2007+）
 * Xlsx文件的解析，Xlsx文件相当于一个伪装的zip包，本质是一个xml文件
 * 这里用POI来解析，还有别的解析方法如Alibaba EasyExcel，Apache Tika，JExcelApi(老，仅支持xls)
 */
@Component
public class XlsxParser implements FileParser {

    // 日期格式化器（统一日期输出格式）
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * 解析XLSX文件，返回1结构化数据
     * @param file
     * @return
     * @throws Exception
     */
    @Override
    public FileParseResult parse(MultipartFile file) throws Exception {
        FileParseResult result = new FileParseResult();
        List<String> headers = new ArrayList<>();
        List<List<Object>> dataRows = new ArrayList<>();

        try(   //HSSFWorkbook  加载 XLSX 文件（XSSFWorkbook 是POI处理 XLSX 的核心类）
                InputStream in =file.getInputStream();
                HSSFWorkbook workbook = new HSSFWorkbook(in);
        ){
            //获取第一个工作表，xlsx文件可能有多个sheet表（暂时先默认指定第一个），多表可以遍历workbook.getNumberOfSheets()
            Sheet sheet = workbook.getSheetAt(0);
            //先判断
            if(sheet==null){
                result.setSuccess(false);
                result.setErrorMessage("XLSX 文件中第一个表是空的");
                return result;
            }
            // 遍历所有行（跳过空行）
            Iterator<Row> rowIterator = sheet.iterator();//迭代器
            int rowIndex = 0;
            while(rowIterator.hasNext()){
                Row row = rowIterator.next();
                //是空的话就跳过
                if(isRowEmpty(row)){
                    continue;
                }
                //  解析数据行（转换为 <表头>）
                if(rowIndex==0){
                    headers=parseHeaderRow(row);
                    rowIndex++;
                    continue;
                }

                //如果需要表头映射的话
//              Map<String, Object> rowData = new parseDataRow(row,headers);
                List<Object> rowData = parseToLists(row);
                dataRows.add(rowData);
                rowIndex++;
            }
            // 6. 填充解析结果
            result.setSuccess(true);
            result.setHeaders(headers);
            result.setDataRows(dataRows);
            result.setTotalRows(dataRows.size()); // 总数据行数（不含表头）
        }catch (Exception e){
            result.setSuccess(false);
            result.setErrorMessage("解析 XLSX 失败：" + e.getMessage());
        }

        return result;
    }

    /**
     * 解析表头
     * @param row
     * @return
     */
    private List<String> parseHeaderRow(Row row){
        List<String> headers = new ArrayList<>();
        // 遍历行中所有单元格（包括空单元格）
        for (int cellNum = 0; cellNum < row.getLastCellNum(); cellNum++) {
            Cell cell = row.getCell(cellNum, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
            headers.add((String) getCellValue(cell)); //也可以加一个去除首位空格的
        }
        return headers;
    }

    // 解析工作表并转换为 List<List<Object>>
    public List<Object> parseToLists(Row row){
        List<Object> result = new ArrayList<>();
        int lastCellNum = row.getLastCellNum();
        for (int cellNum = 0; cellNum < lastCellNum; cellNum++) {
            Cell cell = row.getCell(cellNum, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK); // 空单元格视为空值
           Object value = convertCellValue(cell); // 转换单元格值为对应类型
            result.add(value);
        }
        return result;
    }

    /**
     * 解析数据行，转换为 Map<表头, 值>
     */
//    private Map<String, Object> parseDataRow(Row row, List<String> headers) {
//        Map<String, Object> dataRow = new HashMap<>();
//        int lastCellNum = Math.min(row.getLastCellNum(), headers.size()); // 避免单元格数超过表头数
//
//        for (int cellNum = 0; cellNum < lastCellNum; cellNum++) {
//            String header = headers.get(cellNum); // 表头字段名
//            Cell cell = row.getCell(cellNum, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK); // 空单元格视为空值
//            Object value = convertCellValue(cell); // 转换单元格值为对应类型
//
//            dataRow.put(header, value);
//        }
//        return dataRow;
//    }

    /**
     * 转换单元格值为 Java 类型（自动识别字符串、数字、日期等）
     */
    private Object convertCellValue(Cell cell) {
        if (cell == null) {
            return "";
        }

        switch (cell.getCellType()) {
            case STRING:
                // 字符串类型（直接返回）
                return cell.getStringCellValue().trim();
            case NUMERIC:
                // 数字类型（可能是日期或普通数字）
                if (DateUtil.isCellDateFormatted(cell)) {
                    // 日期类型（格式化输出）
                    return DATE_FORMAT.format(cell.getDateCellValue());
                } else {
                    // 普通数字（避免长数字科学计数法，转换为字符串再解析）
                    String numericStr = String.valueOf(cell.getNumericCellValue());
                    // 整数处理（如 123.0 → 123）
                    if (numericStr.endsWith(".0")) {
                        return Long.parseLong(numericStr.substring(0, numericStr.length() - 2));
                    } else {
                        return Double.parseDouble(numericStr);
                    }
                }
            case BOOLEAN:
                // 布尔类型
                return cell.getBooleanCellValue();
            case FORMULA:
                // 公式类型（取计算结果）
                return getFormulaResult(cell);
            default:
                // 其他类型（如错误单元格）返回空字符串
                return "";
        }
    }

    /**
     * 获取公式单元格的计算结果
     */
    private Object getFormulaResult(Cell cell) {
        Workbook workbook = cell.getSheet().getWorkbook();
        FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
        CellValue cellValue = evaluator.evaluate(cell);

        switch (cellValue.getCellType()) {
            case STRING:
                return cellValue.getStringValue();
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    return DATE_FORMAT.format(DateUtil.getJavaDate(cellValue.getNumberValue()));
                } else {
                    return cellValue.getNumberValue();
                }
            case BOOLEAN:
                return cellValue.getBooleanValue();
            default:
                return "";
        }
    }

    /**
     * 判断行是否为空（所有单元格都为空）
     */
    private boolean isRowEmpty(Row row) {
        if (row == null) {
            return true;
        }
        for (int cellNum = row.getFirstCellNum(); cellNum < row.getLastCellNum(); cellNum++) {
            Cell cell = row.getCell(cellNum, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
            if (cell.getCellType() != CellType.BLANK) {
                return false;
            }
        }
        return true;
    }

}
